Roan Dawkins

Unlike most other programming languages, Java has included support for multithreading in the Java Language Specification (JLS) since its inception in 1995 [4]. However, Java’s multithreading model is directly based on Hoare’s monitor concept [9] and uses low-level constructs such as synchronized code blocks, and library routines such as the wait(), notify(), and notifyAll() methods from class Thread. This approach is particularly error-prone as these constructs are easily abused or misunderstood by a programmer without sufficient multi-threading knowledge [4, 8]. Recent work in the field has been based on using one of the following techniques to overcome the shortcomings in Java’s multithreading model: 1) extensions to the monitor concept, 2) message passing, and 3) assertions and preconditions. Guava [1] and Java4P [3] (based on techniques 1, and 3 respectively) are two of several approaches proposed recently to provide a higher-level, less error-prone Java synchronization model. This paper evaluates these approaches using 1) applicability – is the proposed solution capable of solving common synchronization scenarios, 2) invasiveness – to what degree does the approach intrude on new and existing programs, and 3) flexibility – to what granularity is concurrency allowed, in an effort to determine if either approach is better from an application programmer’s perspective.